﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Linq;
using digitwhu.Models.IRepositorys;
using digitwhu.Models;

namespace digitwhu.Models.Repositorys
{
    public class BlogRepository : Repository<OriginalMicroBlog>, IBlogRepository
    {
        public BlogRepository(DataContext dbContext)
            : base(dbContext)
        {

        }
        //关于微博相关的操作
        public IList<int> GetOriginBlog(string type, int placeId)//查询某个地点的所有原创微博编号列表
        {
            //type指明查询看看微博的地点。取值只可能是：building,street
            //placeId指明地点编号，可能是building上面的编号，也可能是street上面的编号
            //返回某个地点的所有原创微博编号列表
            List<int> blogList = new List<int>();
            if (type.Equals("building"))
            {
                //查询某个建筑上面的所有原创微博列表
                var microblog = from b in context.GetTable<BuildingMicroBlog>()
                                where b.building_id == placeId
                                select b.microblog_id;
                foreach (var m in microblog)
                {
                    blogList.Add(m);
                }
            }
            else if (type.Equals("street"))
            {
                //查询某条街道上面的所有原创微博列表
                var microblog = from b in context.GetTable<StreetMicroBlog>()
                                where b.street_id == placeId
                                select b.microblog_id;
                foreach (var m in microblog)
                {
                    blogList.Add(m);
                }

            }
            return blogList;
        }
        public IList<int> GetTranBlog(string type, int placeId) //查询某个地点的所有转发微博编号列表
        {
            //type指明查询看看微博的地点。取值只可能是：building,street
            //placeId指明地点编号，可能是building上面的编号，也可能是street上面的编号
            //返回某个地点的所有转发微博编号列表
            List<int> blogList = new List<int>();
            if (type.Equals("building"))
            {
                //查询某个建筑上面的所有转发微博列表
                var microblog = from b in context.GetTable<BuildingTranBlog>()
                                where b.building_id == placeId
                                select b.tranblog_id;
                foreach (var m in microblog)
                {
                    blogList.Add(m);
                }
            }
            else if (type.Equals("street"))
            {
                //查询某条街道上面的所有转发微博列表
                var microblog = from b in context.GetTable<StreetTranBlog>()
                                where b.street_id == placeId
                                select b.tranblog_id;
                foreach (var m in microblog)
                {
                    blogList.Add(m);
                }
            }
            return blogList;
        }
        public int GetBlogOwner(string type, int blogId)//查询某条微博的主人
        {
            //type指明所查询微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //返回值：正数表示查找成功，返回的是微博主人的用户编号，负数(-1)表示查找失败(可能是参数错误)
            if (type.Equals("transmit"))
            {
                //转发微博的主人
                var blog = from b in context.GetTable<TranMicroBlog>()
                           where b.tranMicroBlogId == blogId
                           select b.userId;
                foreach (var u in blog)
                {
                    return u;
                }

            }
            else if (type.Equals("original"))
            {
                //原创微博的主人
                var blog = from b in context.GetTable<OriginalMicroBlog>()
                           where b.originalBlogId == blogId
                           select b.userId;
                foreach (var u in blog)
                {
                    return u;
                }
            }
            return -1;
        }
        public bool AddTranBlog(int placeId, string placeType, int originBlogId, int userId, string tranReason, int replyType)//转发微博
        {
            //该方法只更新TranMicroBlog表和地址相关表，@表的更新和内容分析在另外专门的函数中解决
            //说明：默认转发微博的标识是逐渐递增的，所以，最大的ID值应该是最新插入记录的ID
            //placeId：转发微博地点编号
            //placeType：转发微博地点类型。取值：building、street
            //originBlogId：待转发的原始微博编号
            //userId：要进行转发微博操作的用户编号
            //tranReason：用户转发该条微博的理由
            //replyType：转发微博的回复类型.取值：1（不可回复），2（仅好友可回复），3（任何人都不可回复）
            //返回转发微博是否成功.
            if (AddTranBlog(originBlogId, userId, tranReason, replyType))   //更新表TranMicroBlog
            {
                //转发微博成功
                int blogId = GetLatestBlogId("transmit");
                if (blogId == -1) return false; //系统错误
                if (placeType.Equals("street"))
                {
                    //街道上面转发微博
                    return this.AddStreetMicroBlog("transmit", placeId, blogId);//更新表格StreetTranBlog

                }
                if (placeType.Equals("building"))
                {
                    //建筑物上面转发微博
                    return this.AddBuildingMicroBlog("transmit", placeId, blogId);//更新表格BuildingTranBlog
                }
                //地址类型错误
                return false;

            }
            else
            {
                //转发微博失败
                return false;
            }
        }
        public bool DeleteBlog(string type, int blogId)  //删除微博
        {
            //type指明要删除的微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //放回删除微博是否成功
            if (type.Equals("transmit"))
            {
                string sql = "DELETE FROM TranMicroBlog WHERE tranMicroBlogId=" + blogId;
                int i = context.ExecuteCommand(sql);    //返回删除的行数
                if (i == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else if (type.Equals("original"))
            {
                string sql = "DELETE FROM OriginalMicroBlog WHERE originalBlogId=" + blogId;
                int i = context.ExecuteCommand(sql);//返回删除的行数
                if (i == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return false;
        }
        public IList<int> GetBlogComment(string type, int blogId)//查询某条微博的所有评论
        {
            //type指明要删除的微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //返回指定微博的所有评论ID列表
            IList<int> comment = new List<int>();
            if (type.Equals("transmit"))
            {
                //转发微博评论
                var com = from c in context.GetTable<TranBlogComment>()
                          where c.tranMicroBlogId == blogId
                          select c;
                foreach (var c in com)
                {
                    comment.Add(c.commentId);
                }
            }
            else if (type.Equals("original"))
            {
                //原始微博评论
                var com = from c in context.GetTable<OriginBlogComment>()
                          where c.originalBlogId == blogId
                          select c;
                foreach (var c in com)
                {
                    comment.Add(c.commentId);
                }
            }
            return comment;
        }
        public int GetLatestBlogId(string type) //查询最新插入微博的编号
        {
            //type指明要查询的微博的类型：取值只可能是:transmit,original
            //返回值:负数（-1）表示错误，正数指明指定类型微博的最新编号
            int blogId = -1;
            if (type.Equals("transmit"))
            {
                //转发微博
                var blog = from b in context.GetTable<TranMicroBlog>()
                           select b;
                foreach (var b in blog)
                {
                    if (b.tranMicroBlogId > blogId)
                    {
                        blogId = b.tranMicroBlogId;
                    }
                }
            }
            else if (type.Equals("original"))
            {
                //原创微博
                var blog = from b in context.GetTable<OriginalMicroBlog>()
                           select b;
                foreach (var b in blog)
                {
                    if (b.originalBlogId > blogId)
                    {
                        blogId = b.originalBlogId;
                    }
                }
            }
            return blogId;
        }
        private bool AddTranBlog(int originBlogId, int userId, string tranReason, int replyType)//单纯转发微博
        {
            //单纯的文本微博转发，不涉及到地图的东西
            //originBlogId：待转发的原始微博编号
            //userId：要进行转发微博操作的用户编号
            //tranReason：用户转发该条微博的理由
            //replyType：转发微博的回复类型。取值：1（不可回复），2（仅好友可回复），3（任何人都不可回复）
            //返回转发微博是否成功.
            string sql = "INSERT INTO TranMicroBlog(originalBlogId,userId,tranDataTime,tranReason,replyType) VALUES(" +
               originBlogId + "," +
               userId + ",'" +
               DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "','" +
               tranReason + "'," +
               replyType + ")";
            int i = context.ExecuteCommand(sql);
            if (i != 1)        //转发微博失败
            {
                return false;
            }
            return true;
        }
        private bool AddStreetMicroBlog(string blogType, int placeId, int blogId)//将微博绑定到指定街道地点
        {
            //更新表StreetMicroBlog或StreetTranBlog
            //blogType指明要绑定的微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //placeId：要绑定的地点编号
            //返回是否板绑定成功
            if (blogType.Equals("transmit"))
            {
                //转发微博
                string sql = "INSERT INTO StreetTranBlog(street_id,tranblog_id) VALUES(" +
                    placeId + "," +
                    blogId + ")";
                int i = context.ExecuteCommand(sql);
                if (i == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                //原创微博
                string sql = "INSERT INTO StreetMicroBlog(street_id,microblog_id) VALUES(" +
                   placeId + "," +
                   blogId + ")";
                int i = context.ExecuteCommand(sql);
                if (i == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        private bool AddBuildingMicroBlog(string blogType, int placeId, int blogId)//将微博绑定到指定建筑物地点
        {
            //更新表BuildingMicroBlog或BuildingTranBlog
            //blogType指明要绑定的微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //placeId：要绑定的地点编号
            //返回是否板绑定成功
            if (blogType.Equals("transmit"))
            {
                //转发微博
                string sql = "INSERT INTO BuildingTranBlog(building_id,tranblog_id) VALUES(" +
                    placeId + "," +
                    blogId + ")";
                int i = context.ExecuteCommand(sql);
                if (i == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                //原创微博
                string sql = "INSERT INTO BuildingMicroBlog(building_id,microblog_id) VALUES(" +
                   placeId + "," +
                   blogId + ")";
                int i = context.ExecuteCommand(sql);
                if (i == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        public bool AddComment(string type, int blogId, int userId, string comment)//评论微博
        {
            //评论微博要对评论的comment进行分析，是否含有@消息,此步骤在逻辑分析层完成
            //type指明要被评论的微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //userId指明要评论该微博的用户编号
            //comment指明用户的评论内容
            //返回是否评论成功
            if (type.Equals("transmit"))
            {
                //评论转发微博
                string sql = "INSERT INTO TranBlogComment(tranMicroBlogId,userId,commentDateTime,comment) VALUES(" +
                    blogId + "," +
                    userId + ",'" +
                    DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "','" +
                    comment + "')";
                int i = context.ExecuteCommand(sql);//影响的行数
                if (i != 1)
                {
                    return false;
                }
                return true;
            }
            else if (type.Equals("original"))
            {
                //评论原创微博
                string sql = "INSERT INTO OriginBlogComment(originalBlogId,userId,commentDateTime,comment) VALUES(" +
               blogId + "," +
               userId + ",'" +
               DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "','" +
               comment + "')";
                int i = context.ExecuteCommand(sql); ;//影响的行数
                if (i != 1)
                {
                    return false;
                }
                return true;
            }
            return false;
        }
        public int GetLatestCommentId(string type)//获得最新插入评论的编号
        {
            //默认评论的编号是自动增长的。所以最大值的编号是最新插入的评论ID
            //type指明要获得的微博的类型：取值只可能是:transmit,original
            //返回值：负数（-1）表示错误，正数表示最新插入评论的编号
            int commentId = -1;
            if (type.Equals("transmit"))
            {
                var comment = from b in context.GetTable<TranBlogComment>()
                              select b;
                foreach (var b in comment)
                {
                    if (b.commentId > commentId)
                    {
                        commentId = b.commentId;
                    }
                }
            }
            else if (type.Equals("original"))
            {
                var comment = from b in context.GetTable<OriginBlogComment>()
                              select b;
                foreach (var b in comment)
                {
                    if (b.commentId > commentId)
                    {
                        commentId = b.commentId;
                    }
                }
            }
            return commentId;
        }
        public bool DeleteComment(string type, int commentId) //删除某条评论
        {
            //type指明要删除评论的微博的类型：取值只可能是:transmit,original
            //commentId是评论的编号
            string sql = "";
            if (type.Equals("transmit"))
            {
                //删除对转发微博的评论
                sql = "DELETE FROM TranBlogComment WHERE commentId=" + commentId;
                int i = context.ExecuteCommand(sql);
                if (i == 1)
                {
                    return true;//删除成功
                }
                return false;//删除异常
            }
            else if (type.Equals("original"))
            {
                //删除对原创微博的评论
                sql = "DELETE FROM OriginBlogComment WHERE commentId=" + commentId;
                int i = context.ExecuteCommand(sql);
                if (i == 1)
                {
                    return true;//删除成功
                }
                return false;//删除异常
            }
            return false;//输入参数type错误
        }
        public bool AddOriginBlog(int placeId, string placeType, int userId, string content, int replyType)//发布原创微博
        {
            //placeId：发布微博地点编号
            //placeType：发布微博地点类型。取值：building、street
            //userId：要发布的用户编号
            //content：发布微博内容
            //replyType：转发微博的回复类型.取值：1（不可回复），2（仅好友可回复），3（任何人都不可回复）
            //返回发布微博是否成功
            if (AddOriginBlog(userId, content, replyType))//更新表OriginalMicroBlog
            {
                //创建原始微博成功
                int blogId = GetLatestBlogId("original");
                if (blogId == -1) return false; //系统错误
                if (placeType.Equals("street"))
                {
                    //街道上面发微博
                    return this.AddStreetMicroBlog("original", placeId, blogId);//更新表格StreetMicroBlog

                }
                if (placeType.Equals("building"))
                {
                    //建筑物上面发微博
                    return this.AddBuildingMicroBlog("original", placeId, blogId);//更新表格BuildingMicroBlog
                }
                //此时地址类型错误
                return false;
            }
            else
            {
                return false;
            }
        }
        private bool AddOriginBlog(int userId, string content, int replyType)//发布纯文本微博
        {
            //单纯的微博，不涉及到地图的东西
            //userId：要发布的用户编号
            //content：发布微博内容
            //replyType：转发微博的回复类型.取值：1（不可回复），2（仅好友可回复），3（任何人都不可回复）
            //放回发布微博是否成功
            string sql = "INSERT INTO OriginalMicroBlog(userId,blogDateTime,blogContent,replyType) VALUES(" +
               userId + ",'" +
               DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "','" +
               content + "'," +
               replyType + ")";
            int i = context.ExecuteCommand(sql);
            if (i != 1)        //发送微博失败
            {
                return false;
            }
            return true;
        }
        public bool GetBlogIsUserAttention(string type, int blogId, int userId)//查询某条微博是不是用户关注的好友微博
        {
            //type指明要查询微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //userId指明要查询的用户编号
            //返回值：true：是好友微博，false：不是好友微博
            if (type.Equals("transmit"))
            {
                //转发微博
                var id = from b in context.GetTable<TranMicroBlog>()
                         where b.tranMicroBlogId == blogId
                         select b.userId;//id应该是唯一的
                int ID = id.First<int>();
                var attention = from a in context.GetTable<Attention>()
                                where a.userPayAttention == userId
                                select a.userBeFocused;//返回用户userId关注的好友列表
                foreach (var u in attention)
                {
                    if (ID == u)
                    {
                        return true;//查找成功
                    }
                }
                return false;   //查找失败
            }
            else if (type.Equals("original"))
            {
                //原创微博
                var id = from b in context.GetTable<OriginalMicroBlog>()
                         where b.originalBlogId == blogId
                         select b.userId;//id应该是唯一的
                int ID = id.First<int>();
                var attention = from a in context.GetTable<Attention>()
                                where a.userPayAttention == userId
                                select a.userBeFocused;//返回用户userId关注的好友列表
                foreach (var u in attention)
                {
                    if (ID == u)
                    {
                        return true;//查找成功
                    }
                }
                return false;   //查找失败
            }
            return false;//type类型错误
        }
        public bool GetBlogIsInUserBlack(string type, int blogId, int userId)//查询某条微博是不是被用户userId拉黑了的人的微博
        {
            //type指明要查询微博的类型：取值只可能是:transmit,original
            //blogId指明微博的编号
            //userId指明要查询的用户编号
            //返回值：true：是被拉黑的人的微博，false：不是被拉黑的人的微博
            if (type.Equals("transmit"))
            {
                //转发微博
                var id = from b in context.GetTable<TranMicroBlog>()
                         where b.tranMicroBlogId == blogId
                         select b.userId;//id应该是唯一的
                int ID = id.First<int>();
                var blacklist = from a in context.GetTable<BlackList>()
                                where a.userMakeBlack == userId
                                select a.userBeBlack;//返回用户userId拉黑的人的userId列表
                foreach (var u in blacklist)
                {
                    if (ID == u)
                    {
                        return true;//查找成功
                    }
                }
                return false;   //查找失败
            }
            else if (type.Equals("original"))
            {
                //原创微博
                var id = from b in context.GetTable<OriginalMicroBlog>()
                         where b.originalBlogId == blogId
                         select b.userId;//id应该是唯一的
                int ID = id.First<int>();
                var blacklist = from a in context.GetTable<BlackList>()
                                where a.userMakeBlack == userId
                                select a.userBeBlack;//返回用户userId拉黑的人的userId列表
                foreach (var u in blacklist)
                {
                    if (ID == u)
                    {
                        return true;//查找成功
                    }
                }
                return false;   //查找失败
            }
            return false;//type类型错误
        }
    }
}